Method for data driven application integration for B2B

ABSTRACT

Aspects of the present embodiments provide an eCommerce environment adapted to accept and process various message types (e.g. cXML and mXML). In general, requests are provided from a requesting entity to an application hosting entity. Data from incoming requests are mapped to a format understandable to an appropriate application(s). Responses from the application(s) are then mapped into a response format acceptable by the requesting entity. 
     To this end, embodiments disclosed herein provide processes for the development and execution of a data driven process for mapping multiple request/response message pairs to a single application interface or set of application interfaces. In one embodiment, these processes are driven by development time and run time documents that describe a development time view of the message pairs and the application interfaces as well as runtime instructions for providing the mappings, respectively.

CROSS REFERENCE TO RELATED APPLICATIONS

This is a continuation application of U.S. patent application Ser. No.09/837,041, filed Apr. 18, 2001 now U.S. Pat. No. 7,373,349, entitled“PROCESS FOR DATA DRIVEN APPLICATION INTEGRATION FOR B2B”, which isherein incorporated by reference

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates to distributed systems configured toprocess requests provided in different formats.

2. Background of the Related Art

Wide area networks such as the Internet provide a convenient forum forengaging in a variety of commercial activities, generally referred to aseCommerce. A typical eCommerce environment 100 comprising buyers andsellers connected by the Internet is illustrated in FIG. 1. In theillustrative buyer/supplier model, a buyer organization 102 haspurchased procurement software 103 from a third party vendor. Theprocurement software 103 allows an individual in the buying organization102, commonly referred to a requisitioner 104, to use a browser to makepurchases. The requisitioner 104 can choose from a list of approvedcatalogs and shop for the desired items. The catalogs are hosted locallyat the buyer organization 102 on a catalog server 106. The cataloginformation is uploaded to the catalog server 106 by a supplier 110 ₁,110 ₂, . . . 110 _(N). Each supplier 110 _(N) is responsible providingtheir catalog information to the buyer organization 102.

Viewing the catalog, the requisitioner 104 selects the items andquantities needed. When finished, this order is submitted and capturedby the procurement software.

The procurement software 103 next notifies a designated approver 108that a new order request has been placed. The approver 108 is part ofthe buying organization and uses a browser to view the order and makeany necessary changes in price and/or quantities. If the request lookssatisfactory, the approver 108 approves the order request.

An approved order request results in a purchase order (PO) message beingsent by the procurement software 103 to the appropriate supplier 110_(N) of the goods. The supplier 110 _(N) accepts the PO, processes it asnecessary and sends a PO response message to indicate that the order wasaccepted.

FIG. 2 shows an alternative eCommerce environment 200 in which arequisitioner 204 of a buying organization 202 is provided with theability to shop from a remote catalog hosted directly at the web site ofa supplier 210 _(N). In this scenario, the requisitioner 204 again usesa browser to choose an approved catalog to shop from. The procurementsoftware 203 then indicates that the catalog is hosted remotely. Theprocurement software 203 obtains, either from local storage or from thesupplier site, the URL to use for shopping the catalog and returns thisinformation to the browser of the requisitioner 204. The requisitioner204 then shops the remote catalog and places items in a shopping cart.Upon completion, the requisitioner 204 confirms the order and checksout. The supplier 210 _(N) is then responsible for sending the shoppingcart contents to an approver 208 of the buyer organization 202. Theremaining steps are as those described with reference to FIG. 1. Thus,the approver 208 approves the order and causes a PO to be sent to thesupplier 210 _(N). The supplier 210 _(N) processes the PO by integratingit with back-end applications or by directing it to a commerceapplication for processing.

One problem with conventional eCommerce systems is that the buyingorganizations are installing newer versions of procurement software inan attempt to streamline the purchasing process and reduce expenses.These versions utilize protocols not supported by the legacy systems ofthe suppliers. These protocols include XML-based protocols, such asCommerce XML (cXML), which allow buyers to communicate with multipleseller organizations. Accordingly, buyers are motivated to do businesswith suppliers that support the new protocols. Suppliers must thereforesupport these new protocols or be at a competitive disadvantage to thosesellers who do support the protocols. To this end, suppliers must eitherinstall new applications or find a means to support the new protocolsusing the existing order processing software (e.g., reprogram the legacyequipment). Installing new applications and reprogramming existingsoftware are both cost prohibitive and therefore not viable solutions.

There are several existing products that attempt to address integrationof existing business solutions with defined B2B protocols. In general,exiting solutions allow an XML formatted message to be mapped to one ormore business applications for processing. However, the user is requiredto have knowledge of all fields in the XML message that apply to a giventype of B2B request. Furthermore, some products require a unique adapterprogram to be generated for each B2B request type to be mapped to agiven business application. This adapter program must be ported,compiled and installed on the platform hosting the target businessapplications.

Therefore, there is a need, in an eCommerce environment, to processrequests having various formats including formats notoriginally/directly supported by supplier's applications.

SUMMARY OF THE INVENTION

A method of processing eCommerce requests is provided. The methodcomprises receiving a request of a first request type comprising a firstplurality of input fields; determining an application to invoke, whereinthe application is configured to process a request of a second requesttype comprising a second plurality of input fields; invoking an accessmethod, wherein the access method is configured to define an interfaceof the application for the second request type; mapping at least aportion of the first plurality of input fields to the second pluralityof input fields; and invoking the application.

BRIEF DESCRIPTION OF THE DRAWINGS

So that the manner in which the above recited features and embodimentsare attained and can be understood in detail, a more particulardescription of the invention, briefly summarized above, may be had byreference to the embodiments thereof which are illustrated in theappended drawings.

It is to be noted, however, that the appended drawings illustrate onlytypical embodiments of this invention and are therefore not to beconsidered limiting of its scope, for the invention may admit to otherequally effective embodiments.

FIG. 1 shows a typical eCommerce environment comprising buyers andsellers connected by the Internet.

FIG. 2 shows an alternative eCommerce environment in which arequisitioner of a buying organization is provided with the ability toshop from a remote catalog hosted directly at the web site of asupplier.

FIG. 3 shows a high level diagram of an embodiment of a B2B environment.

FIG. 4 shows a B2B environment which, in one embodiment, may beunderstood as a more detailed illustration of the B2B environment shownin FIG. 3.

FIG. 5 shows an exemplary Application Connector Document.

FIG. 6 shows a relational diagram of two request message formats and anaccess method for an application.

FIG. 7 shows an embodiment of a runtime metadata document.

FIG. 8 shows a data flow diagram illustrating development and deploymentof specification artifacts.

FIG. 9 shows a data flow diagram illustrating deployment of process flowmodels.

FIG. 10 shows a data flow diagram illustrating deployment ofspecification artifacts and processing requests.

FIG. 11 shows a flow chart of a flow manager configured to handleeCommerce requests.

FIG. 12 shows a data flow diagram illustrating a price check.

FIG. 13 shows a graphical user interface of a specification developmenttool.

FIG. 14 shows a graphical user interface of a specification developmenttool.

FIG. 15 shows a graphical user interface of a specification deploymenttool.

FIG. 16 shows a graphical user interface of a deployment tool.

FIG. 17 shows a graphical user interface of a deployment tool.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Introduction

Aspects of the present invention provide an eCommerce environmentadapted to accept and process various message types (e.g. cXML andmXML). In general, requests are provided from a requesting entity to anapplication hosting entity. Data from incoming requests are mapped to aformat understandable to an appropriate application(s). Responses fromthe application(s) are then mapped into a response format acceptable bythe requesting entity.

To this end, embodiments disclosed herein provide processes for thedevelopment and execution of a data driven process for mapping multiplerequest/response message pairs to a single application interface or setof application interfaces. In one embodiment, these processes are drivenby development time and run time documents that describe a developmenttime view of the message pairs and the application interfaces as well asruntime instructions for providing the mappings, respectively. As usedherein, “development time” documents/view refers to various artifactsthat describe flow processing and mapping rules. “Run time”documents/view refers to the collection of software components thatoperate to implement the flow processing and mapping rules.

As used herein, “mapping” generally refers to the process of relatingone input to another input. For example, mapping includes converting amessage in one format to a message in another format based onpredetermined rules (this may be referred to as message-to-messagetransformation). In addition, mapping refers to extracting a value froma field in a message, converting it to an appropriate data type, andthen placing that data at a location where an application is expectingit. In one aspect, the location may be a message passed into anapplication that is expecting a message as input. In another aspect, thelocation is a parameter on an application that is expecting a set ofparameters on call invocation. The foregoing aspects illustrate inputmapping; however, the present embodiments also provide for outputmapping. Output mapping involves taking values output from anapplication and placing the values in a message in the proper format(i.e., in a format understandable by procurement software).

Accordingly, mapping assumes that the structure of a source and a targetare known. For example, messages are typically broken into separatefields. In XML parlance, fields in a message are delimited by tags whichname an element. A single element has attributes that further describethat element. A single element may also contain other elements withassociated attributes. In non-XML messages, fields may be arbitrarilydefined by the message designer as structures, strings or bits, etc. Themapping rules indicate how a particular source field is to be processedand subsequently placed into a target field. An example of mappingaccording to the embodiments provided herein would be associating aproduct number from a B2B request to a parameter of a program.

Mapping is needed because two separately developed applications orprocesses rarely have the same input and output requirements in terms ofmessage format and/or data. Such applications that were not originallydesigned to communicate with one another require an intermediateprocess, such as those described herein, that allow the applications tocommunicate with each other without modification.

Embodiments described herein use a markup language known as extensiblemark up language (XML) to advantage. XML is a popular, well-acceptedlanguage in the industry. Because many tools are available to processXML documents, viewing such documents for purposes of education anddebugging is made easy. In addition, the extensible nature of XMLfacilitates adding functionality to existing products while continuingto maintain compatibility between releases of the products. These andother advantages make XML an excellent candidate for the methods andsystems of the present application. However, embodiments of theinvention are not limited to XML or XML-based protocols and theinventors contemplate using other languages, known and unknown.Accordingly, reference to XML and other specific languages and protocolsis merely illustrative.

Moreover, while the embodiments have and hereinafter will be describedin the context of fully functioning computers and computer systems,those skilled in the art will appreciate that the various embodiments ofthe invention are capable of being distributed as a program product in avariety of forms, and that embodiments of the invention apply equallyregardless of the particular type of signal bearing media used toactually carry out the distribution. Examples of signal bearing mediainclude, but are not limited to, recordable type media such as volatileand nonvolatile memory devices, floppy and other removable disks, harddisk drives, optical disks (e.g., CD-ROMs, DVDs, etc.), and transmissiontype media such as digital and analog communication links. Transmissiontype media include information conveyed to a computer by acommunications medium, such as through a computer or telephone network,and includes wireless communications. The latter embodiment specificallyincludes information downloaded from the Internet and other networks.Such signal-bearing media, when carrying computer-readable instructionsthat direct the functions of the present invention, representembodiments of the present invention.

System Architecture, Data Structures, Data Processors and Interfaces

FIG. 3 shows a high level diagram of an embodiment of a B2B environment300. The environment generally includes a plurality of trading partners302 connected to a supplier system 304 via a network 306 (e.g., theInternet). The trading partners 302 execute procurement software togenerate a B2B request and transmit the request to the supplier system304. Illustrative requests include purchase orders (PO), order statuschecks, and catalog maintenance. The supplier system 304 includes afront-end gateway 308 adapted to handle the interfacing with the tradingpartners 302 over a variety of connectivity mechanisms and protocols. Inone embodiment, the front-end gateway 308 includes a collection offront-end protocols 310 to support the requests received from thetrading partners 302. The front-end protocols 310 may be plug-ins andmay be installed locally from a signal-bearing medium (e.g., a CD-ROM)or downloaded from the network 306.

A back-end flow manager 312 and the front-end gateway 308 communicatevia a transport mechanism 316. In one embodiment, the transportmechanism 316 is a queuing mechanism. The back-end flow manager 312 isresponsible for processing the requests by tying them to an appropriateapplication 314 (e.g., Enterprise Resource Planning (ERP), supply chainapplication, etc.). Back-end access methods 318 are provided tofacilitate a connection with the appropriate application 314. As withthe front-end protocols 310, the access methods 318 may be installedlocally or downloaded from a remote site on the network 306. Each accessmethod 318 is configured to handle a particular type of interfacingmechanism, as will be described in more detail below.

For simplicity, the front-end gateway 308 and the back-end flow manager312 are shown as an integral part of a single system. However, inanother embodiment, the front-end gateway 308 and the back-end flowmanager 312 reside on different systems remotely located from oneanother. Such a distributed embodiment is facilitated by the use oftransport mechanisms (e.g., transport mechanism 316) to communicate.

FIG. 4 shows a B2B environment 400 which, in one embodiment, may beunderstood as a more detailed figure of the B2B environment 300 shown inFIG. 3. Accordingly, in some cases, like numbers have been used tocorrelate FIGS. 3 and 4. In general, the B2B environment 400 includestrading partners 302 connected to the supplier system 304 via network306. The trading partners 302 receive responses from the supplier system304 in response to requests. The requests may be any variety ofprotocols, such as cXML from Ariba and mXML from Metiom. Other protocolsinclude xCBL, OCI, and ebXML. Accordingly, the supplier system 304 isconfigured to support the protocols used by the trading partners 302.

The supplier system 304 includes a front-end gateway 404 connected to anHTTP server 402. The HTTP server 402 is configured to receive and sendmessages from/to the network 306 in the popular transfer protocol knownas hyper-text-transfer-protocol (HTTP). Incoming requests are sent fromthe HTTP server 402 to the front-end gateway 404 which, in a particularembodiment, is implemented as a Java servlet. As such, the suppliersystem 400 includes an application servlet engine 406 to allowcommunication between the HTTP server 402 and the front-end gateway 404.Two available engines that may be used to advantage are (1) theWebSphere Application Server used in combination with the IBM HTTPserver and (2) the Domino server. The Domino server has a built-inservlet engine and an HTTP server that can also be used to host Javaservlets.

The front-end gateway 404 is responsible for examining and validatingincoming requests. Any authentication and authorization informationassociated with a particular request is validated. In some cases,requests need to be transformed by the front-end gateway 404 to anormalized format consumable by a back-end flow manager 408. In othercases requests are passed exactly as received. For example, in oneembodiment, the back-end flow manager 408 is configured for XML. If therequests are received in a format other than XML, the front-end gateway404 is configured to convert the request into an XML representation.

The front-end gateway 404 communicates with the back-end flow manager408 via a queuing mechanism 410, such as MQ Series from IBM. Thus, uponvalidating, authenticating and, in some cases, transforming an incomingmessage, the message is placed on the queuing mechanism 410. Thefront-end gateway 404 then waits for an associated response from theback-end flow manager 408 on a response queue.

The back-end flow manager 408 is configured to map incoming requestsinto a format understandable by a plurality of applications 412 and thenreturn an appropriate response. Illustratively, the rules for mappingthese messages are provided as a series of XML documents which embodythe mapping rules used to associate data provided with a B2B request andthe interface defined for an existing application. These documents arereferred to herein as a runtime metadata document 422 (also referred toherein as the “runtime metadata 422”).

In one embodiment, the runtime metadata document 422 is created and/orutilized by tools 413 (also referred to herein as “tools suite 413”). Inone embodiment, the tools 413 comprise a Process Deployment Tool 413Aand a Business Process Editor Tool 413B. The Business Process EditorTool 413B in turn comprises an ACD creation tool 424 and a Process Flowcreation tool 426. These XML documents and the tools 413 will bedescribed in more detail below.

Illustratively, the applications 412 include Java classes, ERPapplications, legacy business applications and data, MQ applications,and custom applications. For each application type, an access method 414(which may also be referred to herein as a “connector”) is provided. Theaccess methods 414 are adapted to support an appropriate interfacingmechanism for each application 412. For the applications 412 shown inFIG. 4, three popular interfacing mechanisms are program calls, queuesand Java methods. Accordingly, the supplier system 304 of FIG. 4includes three access methods 414: a Java access method 414 a, a programcall access method 414 b, and a queue application access method 414 c.

It is understood that the applications 412 and the access methods 414shown in FIG. 4 are merely illustrative and the supplier system 304 maysupport any number of applications 412 and access methods 414. Forexample, the supplier system 304 may also include an SQL access methodfor databases. For brevity, discussion of specific access methods 414 islimited to the Java access method 414 a, the program call access method414 b, and the queue application access method 414 c.

In general, an access method 414 is the “template” for an access methodinstance. Thus, an access method 414 is specialized into a specificaccess method instance, herein referred to as an Application ConnectorDocument (ACD). By analogy to object oriented programming, the accessmethod 414 can be thought of like a class and the access method instance(i.e., the ACD) is like an object. ACDs are described in more detailbelow.

Each access method 414 defines properties that are needed by the accessmethod 414. Properties are name-value pairs that are presented to an enduser at deployment time and allow for configuration information to bepassed to the access method 414. For example, a property may be a systemname, a user profile, a class name or a path to a document. In oneembodiment, properties will always be strings and may have defaultvalues or values set at deployment.

Each access method 414 also has a mechanism used to define input andoutput fields. In one embodiment, such mechanisms include a PCML(Program Call Markup Language) documents and XML documents. PCMLdocuments provide a rich tag specification for describing parameters toa program. The PCML document may be optimized to define a fixedstructure buffer which is passed into an application. An XML document isa tagged string that is self-describing and can be used for applicationsthat require XML as input.

Which mechanism/document to use depends on the nature of the application412 to be accessed. An access method 414 may support one or both ofthese mechanisms. If an access method 414 uses PCML as the technique fordefining input and outputs, then a property field can be defined tocontain a path to the PCML document. This allows the creator of theaccess method 414 to specify the PCML document that describes theinput/output to the application. If an access method 414 uses XML as thetechnique for defining input and output fields, then two property fieldsmay be defined, one to contain a path to the XML document for input andone for the path to the XML document for output.

Illustratively, each access method 414 contains a root element called“Connector” that contains properties, input and output elements. Theproperties element contains a set of elements with names for theproperties that access method 414 has defined. In one embodiment, theproperties of an access method 414 are specified by a user using a tool,as will be described in more detail below. Once the properties have beendefined to the tool, the tool will present them to an administrator sothat values can be provided. In addition, the tool will allow theadministrator to map fields from the input/output message to theapplication interface (input/output fields). When the administrator hasfinished providing all the information required, the tool will generatea runtime metadata specification that will be used by the back-end flowmanager 408 to invoke the access method 414.

PCML Access Method: The program call access method 414 b can be used tocall any program resident locally or remotely. In one embodiment, theprogram call access method 414 b is a PCML document that describes theprogram to be called and the parameters expected by that program.

The properties that are defined for an exemplary program call accessmethod 414 b are shown in Table I.

TABLE I 001 <!ELEMENT connector (properties,input,output)> 002 <!ATTLISTconnector 003 type NMTOKEN #FIXED “programcall” 004 name CDATA #REQUIRED005 version (1.0) #REQUIRED 006 > 007 <!ELEMENT properties(system,userid,password,pcmldocument)> 008 <!ELEMENT system (#PCDATA)>009 <!ELEMENT userid (#PCDATA)> 010 <!ELEMENT password (#PCDATA)> 011<!ATTLIST password 012 encrypt (yes) #REQUIRED 013 > 014 <!ELEMENTpcmldocument (#PCDATA)> 015 <!ELEMENT input (field*)> 016 <!ATTLISTinput 017 type (pcml) #REQUIRED 018 > 019 <!ELEMENT output (field*)> 020<!ATTLIST output 021 type (pcml) #REQUIRED 022 > 023 <!ELEMENT fieldEMPTY> 024 <!ATTLIST field 025 ref CDATA #REQUIRED 026 display (yes |no) #REQUIRED 027 name CDATA #IMPLIED 028 default CDATA #IMPLIED 029 >

The program call access method 414 a only supports a PCML interfacedefinition. A business partner or customer who desires to create aninstance of the PCML access method 414 a to invoke a specificapplication 412 generates a PCML document to describe the interface tothe specific application. For example, assume an application 412 that isgoing to be invoked with the program call access method 414 a has threeinput fields and two output fields. A user writes a PCML document thatlists the name of the application, the three input fields and the twooutput fields.

Queue Access Method: The queue application access method 414 c is usedto send and receive messages on a queuing mechanism, such as an MQSeries queue or an iSeries data queue, both available from IBM. Thequeues can be defined locally or on a remote system. The queueapplication access method 414 c defines the format of the message to beplaced on the queue and, illustratively, is a PCML document or an XMLdocument. The message is in a format expected by the receivingapplication 412.

In one embodiment, the queue application access method 414 c supportstwo queue techniques: iSeries 400 data queues and MQ series queues, bothavailable from IBM. The queue application access method 414 c may alsosupport two interface specification techniques: PCML and XML. Therefore,in one embodiment, the properties define a sending queue (required,SendQueue) and a receiving queue (optional, ReceiveQueue). Theproperties defined for one embodiment of the queue application accessmethod 414 c are shown in Table II.

TABLE II 001 <!ELEMENT connector (properties,input,output)> 002<!ATTLIST connector 003 type CDATA #FIXED “DataQueue” 004 name CDATA#REQUIRED 005 connectversion (1.0) #REQUIRED 006 > 007 <!ELEMENTproperties 008 (MessageType,DQSendKeyed,DQSendKey,DQSendQueueName,DQSendLibrary,DQReceiveKeyed,DQReceiveKey, DQReceiveQueueName,DQReceiveLibrary,DQReceiveWaitTime,pcmldocument,system,userid,password)> 009 <!ELEMENT input (docref,field*)> 010<!ATTLIST input 011 type (pcml | xml | all) #IMPLIED 012 > 013 <!ELEMENToutput (docref,field*)> 014 <!ATTLIST output 015 type (pcml | xml | all)#IMPLIED 016 > 017 <!ELEMENT MessageType (#PCDATA)> 018 <!ATTLISTMessageType 019 proptype CDATA #FIXED “list(pcml;xml;csv)” 020 defaultCDATA #IMPLIED 021 label CDATA #FIXED “Message Type” 022 > 023 <!ELEMENTDQSendKeyed (#PCDATA)> 024 <!ATTLIST DQSendKeyed 025 proptype CDATA#FIXED “list(yes;no)” 026 default CDATA #IMPLIED 027 label CDATA #FIXED“Keyed Send Queue?” 028 > 029 <!ELEMENT DQSendKey (#PCDATA)> 030<!ATTLIST DQSendKey 031 proptype CDATA #FIXED “string” 032 default CDATA#IMPLIED 033 label CDATA #FIXED “Send Queue Key” 034 enabledBy CDATA#FIXED “DQSendKeyed(yes)” 035 > 036 <!ELEMENT DQSendQueueName (#PCDATA)>037 <!ATTLIST DQSendQueueName 038 proptype CDATA #FIXED “string” 039default CDATA #IMPLIED 040 label CDATA #FIXED “Send Queue Name” 041 >042 <!ELEMENT DQSendLibrary (#PCDATA)> 043 <!ATTLIST DQSendLibrary 044proptype CDATA #FIXED “string” 045 default CDATA #IMPLIED 046 labelCDATA #FIXED “Send Queue Library” 047 > 048 <!ELEMENT system (#PCDATA)>049 <!ATTLIST system 050 proptype CDATA #FIXED “string” 051 defaultCDATA #FIXED “localhost” 052 label CDATA #FIXED “Send-Receive QueueSystem” 053 > 054 <!ELEMENT userid (#PCDATA)> 055 <!ATTLIST userid 056proptype CDATA #FIXED “string” 057 default CDATA #FIXED “” 058 labelCDATA #FIXED “Send-Receive Queue Userid” 059 encrypt CDATA #FIXED “yes”060 > 061 <!ELEMENT password (#PCDATA)> 062 <!ATTLIST password 063proptype CDATA #FIXED “string” 064 default CDATA #FIXED “” 065 labelCDATA #FIXED “Send-Receive Queue Password” 066 encrypt CDATA #FIXED“yes” 067 keyfield CDATA #FIXED “userid” 068 > 069 <!ELEMENTDQReceiveKeyed (#PCDATA)> 070 <!ATTLIST DQReceiveKeyed 071 proptypeCDATA #FIXED “list(yes;no)” 072 default CDATA #IMPLIED 073 label CDATA#FIXED “Keyed Receive Queue?” 074 > 075 <!ELEMENT DQReceiveKey(#PCDATA)> 076 <!ATTLIST DQReceiveKey 077 proptype CDATA #FIXED “string”078 default CDATA #IMPLIED 079 label CDATA #FIXED “Receive Queue Key”080 enabledBy CDATA #FIXED “DQReceiveKeyed(yes)” 081 > 082 <!ELEMENTDQReceiveQueueName (#PCDATA)> 083 <!ATTLIST DQReceiveQueueName 084proptype CDATA #FIXED “string” 085 default CDATA #IMPLIED 086 labelCDATA #FIXED “Receive Queue Name” 087 > 088 <!ELEMENT DQReceiveLibrary(#PCDATA)> 089 <!ATTLIST DQReceiveLibrary 090 proptype CDATA #FIXED“string” 091 default CDATA #IMPLIED 092 label CDATA #FIXED “ReceiveQueue Library” 093 > 094 <!ELEMENT DQReceiveWaitTime (#PCDATA)> 095<!ATTLIST DQReceiveWaitTime 096 proptype CDATA #FIXED “string” 097default CDATA #IMPLIED 098 label CDATA #FIXED “Receive Queue Wait Time”099 > 100 <!ELEMENT pcmldocument (#PCDATA)> 101 <!ATTLIST pcmldocument102 proptype CDATA #FIXED “file” 103 default CDATA #IMPLIED 104 labelCDATA #FIXED “PCML Document” 105 enabledBy CDATA #FIXED“MessageType(pcml)” 106 > 107 <!ELEMENT docref (#PCDATA)> 108 <!ELEMENTfield (field*)> 109 <!ATTLIST field 110 ref CDATA #REQUIRED 111 display(yes | no) #REQUIRED 112 label CDATA #IMPLIED 113 type (char | int |packed | zoned | float | byte | struct) “char” 114 length CDATA #IMPLIED115 precision CDATA #IMPLIED 116 repeating (Yes | No) “No” 117countfield CDATA #IMPLIED 118 default CDATA #IMPLIED 119 >

A business partner or customer who desires to create an instance of thequeue application access method 414 c to pass a message to theirapplication must define queue identification information and has achoice of specifying the message format as an XML document or as astructured buffer with PCML.

Java Access Method: The Java access method 414 a is used to call a userwritten Java method that in turn can call other java programs (local orremote) or access local or remote databases. The data available to thisJava method (i.e., the method called by the Java access method 414 a)may be defined by either a PCML or XML document, for example. The Javaaccess method 414 a is a special case access method that is differentfrom the access methods 414 a and 414 c described above. The accessmethods 414 a and 414 c “drive” the mappings for applications and theninvoke the back-end application 412 with a fully-resolved parameterlist. This design is successful for those access methods 414 becausethey provide a consistent, generic way to describe the applicationinterface (either via PCML and/or XML). For the Java access method 414a, this technique does not work because the Java parameters may beobjects. Objects are more complex and do not facilitate a consistentgeneric way to describe the application interface such that all thediverse parameters types could be built.

Thus, the Java access method 414 a invokes a method that implements aspecific Java interface (referred to as the “JavaConnectorInterface”).The method (herein referred to as the “Interface Method”) thatimplements the interface then performs a set of functions allowing it tobuild the parameters to the targeted back-end application 412. EachInterface Method is configured with very specific “knowledge” of theinterface to the targeted back-end application 412. TheJavaConnectorInterface will pass in an Object (ConnectorParms) to theInterface Method that will contain methods allowing the Interface Methodto get runtime data from/to the request/response messages. Theproperties for one embodiment of a Java access method 414 a are shown inTable III.

TABLE III 001 <!ELEMENT connector (properties,input,output)> 002<!ATTLIST connector 003 type NMTOKEN #FIXED “Java” 004 name CDATA#REQUIRED 005 > 006 <!ELEMENT properties (classname,pcmldocument)> 007<!ELEMENT classname (#PCDATA)> 008 <!ELEMENT pcmldocument (#PCDATA)> 009<!ELEMENT input (alias*)> 010 <!ATTLIST input 011 type (pcml) #REQUIRED012 > 013 <!ELEMENT output (alias*)> 014 <!ATTLIST output 015 type(pcml) #REQUIRED 016 > 017 <!ELEMENT alias EMPTY> 018 <!ATTLIST alias019 ref CDATA #REQUIRED 020 display (yes | no) #REQUIRED 021 label CDATA#IMPLIED 022 >

“Class name” contains the name of the Java class that implements theabstract interface that is defined. The PCML document contains adocument that provides the interface specification for the target Javamethod. The Java access method 414A utilizes an interface class todescribe the interaction between the Java access method 414A and a Javamethod. An illustrative interface class definition is shown in Table IV.

TABLE IV 001 public interface JavaConnectorInterface { 002 publicJavaConnectorResult run (ConnectorParms parameters, String 003PCMLDocName); 004 } 005 006 public class JavaConnectorResult { 007public int returncode; 008 public String returnstring; 009 }

An embodiment of the Java method that implements the Java connectorinterface is shown in Table V.

TABLE V 001 public class GeneralConnector implementsJavaConnectorInterface { 002 public JavaConnectorResult run(ConnectorParms parms, String 003 PCMLDocName { 004 /* get the list ofinput fields */ 005 fields = parms.getinputfieldlist( ); 006 for (/*each field in the fieldlist */) { 007 /* repeat following section foreach field data type */ 008 { 009 / * get the field value by passing inthe name attribute in the 010 field list entry; data type for field willcorrespond to 011 data type specified in the field list entry */ 012 / *an array of values is returned */ 013 For (/*each value in the arraysreturned*/) { 014 /* use the value to set a parameter that will bepassed to the 015 target backend application */ 016 } 017 018 } /* endfor */ 019 /* invoke the real back-end application */ 020 /* get thelist of output fields */ 021 fields = parms.getoutputfieldlist( ); 022for (/* each field in the fieldlist */) { 023 for (/*loop if multiplevalues */) { 024 /* get value generated by target application */ 025 /*use value to update the field identified by the name attribute in 026the field list entry */ 027 }/* end for */ 028 } /* end for */ 029 } 030}Specification Development

A complete specification for servicing a given type of B2B request usingone or more of the existing business application 412 is provided by aspecification suite 415. The specification suite 415 is a collection ofspecification artifacts comprising Application Connector Documents (ACD)416, Process Flow Models (PFM) 418 and Request/Response Message Formats(RMF) 420.

ACDs, PFMs, and RMFs may be created by a variety of methods andentities. In one embodiment, the supplier system 304 includes a toolsuite 413 adapted to create one or more of the artifacts included in thespecification suite 415. The following description further describesaspects of ACDs, PFMs, and RMFs and describes embodiments for theircreation.

ACD: An ACD 416 provides an abstract and reusable interface definitionfor a particular business application 412. A given ACD is unique to aparticular application 412 provides the back-end flow manager the formatof the messages and parameters the application 412 expects. Accordingly,the ACD enables use of that application 412 to service one or more typesof B2B requests. To that end, an ACD describes an access methodinstance. An “instance” is the coupling of an access method 414 with adescription of the data to be processed by that access method 414, i.e.,data passed to an application 412 or placed on the queuing mechanism410. The “description of the data” includes the format of the messagesand parameters expected by an application 412. One or more access methodinstances can be created for each access method 414.

In one embodiment, ACDs 416 are XML documents that adhere to theDocument Type Definition (DTD) defined for the appropriate access method414. An ACD DTD exists for each of the supported access methods 414. AnACD for the Java access method 414 a and the program call access method414 b indicate the name of the class or program to be called and adescription of the parameters the access method expects to be passed. AnACD for the queue access method 414 c indicates the name of the queue touse and the format of the message to place on that queue.

In a particular embodiment, each ACD includes an ACD name, a type of ACD(i.e., the access method 414 this ACD is associated with), specificproperties of the application 412 being accessed (such as system name,user-id and password to use), and the name of documents (referred toherein as input/output documents) that describe the input and outputdata for the application 412. Illustratively, the input/output documentsare PCML or XML documents and may be created using an editor orauthoring tool.

An exemplary ACD 416 is shown in FIG. 5. The ACD 416 defines anencapsulation of a business application 412 or data source by definingboth access method properties 502 and an interface model 504. The accessmethod properties 502 describe how to access the application 412 and theinterface model 504 describes what the application 412 expects for inputand output. Further, the access method properties are information neededby the particular access method at runtime to invoke a targetapplication. Illustratively, a plurality of properties 506 ₁, 506 ₂, . .. 506 _(N), are shown, each comprising a name-value pair. The interfacemodel 504 comprises an input interface 508 and an output interface 510.Each interface 508, 510 comprises a plurality of fields 512 andsub-fields 514 each, in turn, comprising a name-type pair. In general,the interfaces 508, 510 may be a suitable data schema 512 selectedaccording to the application 412 to be accessed. Illustratively, theinterfaces 508, 510 are XML documents or PCML documents.

Illustratively, an ACD can specify default values for fields,hide/expose selected fields from/to a user during flow mapping(described in more detail below) and provide alias names for fields. Adefault value can be used for the contents of a field in the case whereexplicit mapping is not done as part of the mapping rules in a PFM 418.For example, a default value of 1 could be assigned to the quantityfield for a purchase order item, for use when a specific quantity wasnot supplied with the purchase order request data. The ACD specifies foreach field whether the field will be hidden from a user so as not to beconfusing to the user. Thus, an ACD allows control over what portions ofan application's interface are exposed (i.e., displayed for mappingpurposes) in a graphical user interface (GUI). In one embodiment, if afield is to be exposed, alias names are provided for fields within theinput/output documents that are modified at runtime (from data receivedin requests). The alias names provide a convenient expression of fieldswhich is more intuitive than the original format defined by anapplication. These more intuitive alias names may then be used toadvantage in the creation of PFMs 420.

Development of an ACD for a particular application 412 may typically bedone by a provider of a given application 412 or a business partner.Alternatively, it may be done by a service provider during configurationof a supplier's B2B software environment. Although an ACD can bemanually created (e.g., using a text editor or XML editor), oneembodiment provides an ACD Creation tool 424 (a component/function ofthe Business Process Editor 413B) to facilitate creation of ACDs.Regardless of the manner of creation, a completed ACD is then used forflow mapping. In one embodiment, the mapping rules are defined by aProcess Flow Model (PFM) and a single ACD can be reused in multiplePFMs.

One embodiment of an ACD (formatted as an XML document) for a PCML-basedprogram call access method 414 a is shown in TABLE VI.

TABLE VI 001 <?xml version=″1.0″ encoding=″UTF-8″?> 002 <!DOCTYPEconnector SYSTEM 003 ″file://localhost/C:/B2BDTD/PgmConnector.dtd″> 004<connector name=″OrderEntry″ type=″programcall″> 005 <properties> 006<system>rchas001</system> 007 <userid>rstevens</userid> 008 <passwordencrypt=yes>pwval</password> 009 <pcmldocument>orderentrypgm<</pcmldocument> 010 </properties> 011 <input type=″pcml″> 012<docref>orderentrypgm</docref> 013 <field display=″yes″ name=″ItemNumber″ <ref=″xyz.inum″/> 014 <field display=″yes″ name=″Item Quantity″<ref=″xyz.q″ default=”1”/> 015 </input> 016 <output type=″pcml″> 017<docref>orderentrypgm</docref> 018 <field display=″yes″ name=″ItemPrice″ ref=″xyz.p″/> 019 </output> 020 </connector>

RMF: An RMF 418 provides an interface definition of a message format fora given B2B request type (e.g., what are the input and output data flowsfor the request). In one embodiment, an RMF is an XML document.Regardless of the document type used for an RMF, an RMF generallyprovides an association (e.g., mapping) between the contents of arequest and definitional information provided by the RMF. Theassociation is then used to advantage by access methods 414 which accessrequest and response information contained in the RMF without knowingthe physical location of each field in a protocol-specific request.During retrieval and update operations the physical location of data isresolved from an RMF name field by the flow manager 408.

Another feature of an RMF is filtering. Filtering refers to providing aview of or subsetting the complete data structure defined for a givenB2B protocol. Some B2B protocols define a single request/response dataschema for all types of requests supported by the protocol. cXML is anexample of a protocol where a single XML DTD is used to describe dataassociated with all of the requests supported within the protocol. Thisplaces a burden on the business application which must determine whichfields out of the overall data structure apply to each type of request.To obviate this need, a separate RMF may be defined for each requestwithin a given protocol. The RMFs are configured to identify thespecific set of elements and attributes within a given B2B schema thatare used to service a particular type of B2B request. For example, theRMF for a purchase order request defines only the fields that apply to apurchase order request and does not include fields associated with othertypes of requests. In the case of XML-based message formats, a RMF mayidentify the XML DTD or schema associated with the request type and thesubset of fields defined by the DTD or schema that are applicable forB2B requests of this type. Accordingly, RMFs eliminate the need tounderstand (by an application owner attempting to integrate existingapplications with various request formats) which subset of a givenrequest/response data structure applies to each type of request andsimplifies the task of extending an existing business application tohandle new B2B requests. Unlike back-end applications 412, which mayrequire the knowledge of the owner to gain access, request/responsemessage protocols are widely known (that is, generally known to thepublic). Thus, RMFs 418 for each B2B response/request type may beprovided to the supplier system from a third party who need not befamiliar with the implementation of the supplier system 304.

FIG. 6 shows a diagram illustrating the structure of two RMFs and theirrelationship to a business application access method in order to allowfor data interchange within a particular B2B protocol context. A schema602 for an illustrative protocol “X” includes a plurality of Fields 1-4and Sub-fields 2 a-2 b and 4 a. A first RMF (RMF1) and a second RMF(RMF2) are configured to define particular request types for theprotocol “X”. In this case, the first RMF is defined for a request type“A” and the second RMF are defined for a request type “B”.Illustratively, the protocol “X” may be cXML and the request type A is apurchase order while the request type B is a order status inquiry. Thefirst RMF comprises input definition 604 and output definition 606.Similarly, the second RMF comprises input definition 608 and outputdefinition 610. Each of the input/output definitions map to theappropriate fields and sub-fields of the protocol schema 602. In thismanner, a plurality of RMFs may be provided for a single B2B schema.

In one embodiment, RMFs also allow more meaningful and intuitive fieldnames to be associated with elements in a B2B request/response. Such aconfiguration provides a format more understandable to personnelprovided with a B2B request/response, thereby facilitating the processof mapping a request/response to/from an existing business application412. Additionally, RMFs may allow for the definition of a default valueto be used for an output field in cases where explicit mapping is not aspart of the explicit mapping rules in the PFM 420.

Table VII shows one embodiment of an XML DTD which serves as thetemplate for an RMF. Key elements defined in the RMF DTD (Table VII) aredescribed in Table VIII.

TABLE VII 001 <!ELEMENT protocolmessageformat 002(protocol,requestschema,responseschema)> 003 <!ATTLISTprotocolmessageformat 004 version (1.0) #REQUIRED 005 > 006 <!ELEMENTprotocol EMPTY> 007 <!ATTLIST protocol 008 name CDATA #REQUIRED 009protocolversion CDATA #REQUIRED 010 transactiontype CDATA #REQUIRED 011transactionsubtype CDATA #IMPLIED 012 > 013 <!ELEMENT requestschema(field*)> 014 <!ATTLIST requestschema 015 type (DTD) #REQUIRED 016 nameCDATA #REQUIRED 017 > 018 <!ELEMENT responseschema (field*)> 019<!ATTLIST responseschema 020 type (DTD) #REQUIRED 021 name CDATA#REQUIRED 022 > 023 <!ELEMENT field (field*)> 024 <!ATTLIST field 025ref CDATA #REQUIRED 026 name CDATA #IMPLIED 027 default CDATA #IMPLIED028 count (multiple | one) ″one″ 029 >

TABLE VIII RMF Element Description Protocol Identifies theprotocol/transaction/subtype combination this RMF is associated with.Requestschema Identifies the schema which describes the format ofrequest data for this protocol/transaction. In one embodiment, schemasdefined by XML DTDs are supported. Responseschema Identifies the schemawhich describes the format of response data to be generated for thisprotocol/transaction. Field Used to identify the fields in the requestand response schema for this protocol/transaction that are available foruse in mapping to the various ACDs that are defined to handle a givenB2B request. Also allows an alternative name to be associated with thisfield. <field> elements may be nested to reflect the hierarchical natureof the request and response formats supported by various B2B protocols.

Table IX provides an example of an RMF. Illustratively, Table IXillustrates how a monetary amount may be represented in an RMF. In thiscase, money is qualified by a given currency and can also be representedin a different amount in another currency. In one embodiment, keycomponents of an RMF field include label, ref, and context. “Label” isthe abstract name by which access methods and the flow manager 408 referto a given request or response field. Label also serves as the name ofthe field exposed to users through various tools, allowing a moreintuitive name to be used for fields that are poorly named or described.“Ref” is the actual, physical location of the field within the requestor response data structure supported by a given request type. “Context”indicates whether the field is part of the request or response datastructure for the request type.

TABLE IX 001 <field context=“Request” count=“one” label=“Money” ref 002=“/cXML/Request/OrderRequest/OrderRequestHeader/ Shipping/Money”> 003<field context=“Request” count=“one” label=“@currency” ref 004=“/cXML/Request/OrderRequest/OrderRequestHeader/Shipping/Money/@currency”/> 005 <field context=“Request” count=“one” 006label=“@alternateAmount” ref 007=“/cXML/Request/OrderRequest/OrderRequestHeader/Shipping/Money/@alternateAmount”/> 008 <field context=“Request”count=“one” 009 label=“@alternateCurrency” ref 010=“/cXML/Request/OrderRequest/OrderRequestHeader/Shipping/Money/@alternateCurrency”/> 011 </field>

Table X provides RMFs supported in one embodiment. Illustratively, onlyAriba and Metiom message formats are shown. However, any number of RFMsmay be supported.

TABLE X Ariba cXML message format Metiom mXML message format RetrieveProfileRequest N/A Server Response = Capabil- ProfileResponse ities NewOrderRequest with PurchaseOrderMessage Purchase type=new Response =Order Response = Response PurchaseOrderAcknowledgement- Message ChangeOrderRequest with PurchaseOrderChangeRequest- Purchase type=update ordelete Message Order Response = Response Response =PurchaseOrderChangeRequest- AcknowledgementMessage RemotePunchOutSetupRequest N/A Catalog with type= create, edit, Shoppinginspect Request Response = PunchOutSetupResponse ShoppingPunchOutOrderMessage OrderRequestMessage Basket Content Invoice N/AInvoiceMessage

PMF: Once an ACD has been defined for an application and an RMF providedfor a given B2B request type, they can be referenced by a PFM 418 whichserves to map a particular type of B2B request to the application(s)which will be used to service these requests. Thus, a PFM defines thespecific data flow and control flow semantics required to service aparticular B2B request type using one or more business applicationsdescribed by ACDs. In one embodiment, a PFM is an XML document whichdefines 1) the B2B protocol and type of request to be handled, 2) thebusiness application(s) to be used to service the request (specified byan ACD 416), 3) rules for mapping data provided with the B2B request toinput parameters supported by the servicing application(s) and 4) rulesfor mapping output data generated by the application(s) into theresponse message format prescribed by the particular B2Bprotocol/request type. A PFM and the ACDs referenced by a PFM provide acomplete specification of the business applications 412 that are definedto service a particular class of B2B request and rules denoting how datais to be mapped between the formats provided with the B2B request to theformats supported by the servicing business applications.

The PFMs 420 may be created by the creator of the ACD or others who willinclude a particular ACD. In one embodiment, the PFM is created usingthe Process Flow creation tool 426 (a component/function of the BusinessProcess Editor 413B). The Process Flow creation tool 426 helps describethe mapping information by displaying the mappable fields in theincoming transaction requests, as defined by its RMF, and the mappablefields in the ACD and allowing a user to match the appropriate fieldstogether. For example, a user may want to map the “PostalCode” fieldfrom the “BillTo/Address” of a cXML “OrderRequest” message to the“ZipCode” parameter of your “New Order” application.

Tables XI and XII show an exemplary schema for a PFM and an example of amodel defined for mapping order requests to a program call access method414 a, respectively.

TABLE XI Process Flow Model DTD 001 <!ELEMENT processflowmodel(protocol,connector,inmap*, outmap*)> 002 <!ELEMENT protocol> 003<!ATTLIST protocol 004 name CDATA #REQUIRED 005 protocolversion CDATA#REQUIRED 006 transactiontype CDATA #REQUIRED 007 transactionsubtypeCDATA #IMPLIED 008 009 > 010 <!ELEMENT connector EMPTY> 011 <!ATTLISTconnector 012 acdref CDATA #REQUIRED 013 > 014 <!ELEMENT inmap EMPTY>015 <!ATTLIST inmap 016 source CDATA #IMPLIED 017 target CDATA #REQUIRED018 value CDATA #IMPLIED 019 > 020 <!ELEMENT outmap EMPTY> 021 <!ATTLISToutmap 022 source CDATA #REQUIRED 023 target CDATA #REQUIRED 024 >

TABLE XII 001 <?xml version=″1.0″ encoding=″UTF-8″?> 002 <!DOCTYPEprocessflowmodel SYSTEM 003″file://localhost/C:/B2BDTD/ProcessFlowModel.dtd″> 004<processflowmodel> 005 <protocol name=”cXML” protocolversion=”1.0” 006transactiontype=”OrderRequest”/> 007 <connector acdref=″OrderEntry″/>008 <inmapsource=″/ItemOut/ItemID/SupplierPartID″ 009 target=″ItemNumber″/> 010 <inmap source=″ItemOut/@quantity″ target=″Item Quantity″/>011 <outmap source=″Item Price″ target= ″/ItemOut/@price″/> 012</processflowmodel>

Once the ACDs and PFMs are in place, the specification suite 415 isdeployed to provide a runtime view of the artifacts. Deployment involvesassociation of a PFM and one or more ACDs and occurs before receivingrequests. In operation, the deployment of the specification suite 415results in runtime metadata 422. In one embodiment, the runtime metadata422 is an XML document and is structured in such a way as to provideefficient runtime processing. Once generated, the runtime metadata 422is bound to (or associated with) an instance of a flow manager 408. Theruntime metadata 422 may then be used by the flow manager to handleincoming requests and outbound responses of specified types.

There are multiple pieces of information included in the runtimemetadata 422. Illustratively, the runtime metadata 422 includes arequest to flow mapping, a connector interface specification, a flow andresponse creating rules. The request to flow mapping uniquely describesthe requests that should be handled by a particular process flow. Theconnector interface specification is the runtime view of the ACD. Theflow consists of multiple steps that can be taken when handling aparticular request. The flow also describes the field level mappingrules to be applied to each step. The response creating rules arenon-protocol specific rules that allow the flow manager 408 to create avalid response document based on the information in the RMF 420.

In one embodiment, the foregoing runtime metadata 422 components aredefined as XML elements. FIG. 7 shows a runtime metadata document 700containing runtime metadata 422 comprising the following XML elements:Selection 702, Flow 704, Steps 706, Connector 708, Property 710, Field712, Mapin 714, Mapout 716, InsertSpec 718 and ConnectorInterface 720.Arrows denote references from one type of element to another. Thisrepresents a relationship between the two elements but does not implythat one element is necessarily contained within another. This allowsmultiple elements of one type (e.g., the Selection element 702) toreference the same element of another type (e.g., the Flow element 704).In other words, the same Flow element can be used by multipleprotocol/request Selections. These elements are described in more detailbelow with reference to FIG. 11.

To create the runtime metadata 422, one embodiment of the B2Benvironment 400 provides a process deployment tool 413A. Illustratively,the process deployment tool 413A is a component of the tool suite 413.The process deployment tool 413A may be any tool configured to convertthe ACDs and PFMs into a runtime format that can be processed by theflow manager 408. In one embodiment, process deployment tool 413A isaccessed from a browser session and allows a B2B request that is to beserviced to be uniquely identified. A request can be uniquely identifiedby the protocol being used (e.g., cXML, mXML), the marketplace it isreceived from (e.g., Ariba Network, Joe's Fishmarket), the specificAction/Subaction specified (e.g. OrderRequest), the buying organizationsubmitting the request, and the supplier that this request is targeting.The unique request is then associated with a previously built PFM whichidentifies the ACD to be used and the field level mappings to takeplace. In one embodiment, a PFM can reference one ACD and therefore oneback-end application 412. In another embodiment, a PFM can referencemultiple ACDs which constitute a flow. This information is provided tothe flow manager 408 as runtime metadata 422 for real-time processing.At this point, the supplier system 304 is ready to accept requests fromvarious trading partners 302, call the appropriate back-end applications412 and return responses.

System Operation

Development time, deployment and run time may be illustrated withreference to FIGS. 8-12. Referring first to FIG. 8 a method 800 fordevelopment and deployment of ACDs, PFMs, and RMFs is shown. To thisend, method 800 shows a series of steps and indicates the datastructures utilized in the execution of the steps.

Method 800 is entered at step 802 when a user initiates execution of thetools 413. Method 800 then proceeds to step 804 where an ACD is createdto define an instance of an access method 414. At step 806, a PFM iscreated to define a flow using the access method instance. At step 808,the ACD and the PFM are published to (i.e., sent to) a B2B instanceserver. In one embodiment, steps 804-808 employ the Business ProcessEditor 413B. At step 810, the PFM is associated with a request type andis then deployed to a B2B instance. That is, a PFM and its associatedACDs are transformed into runtime metadata. In one embodiment, step 810employs the Process Deployment Tool. The flow manager 408 is nowconfigured with the appropriate runtime metadata to handle a specifiedrequest type.

The relationship between PFMs and a FlowMetaData document is furtherillustrated in FIG. 9. FIG. 9 shows a process flow correlating adevelopment view 902 and a runtime view 904. The development view 902includes a plurality of PFMs 906 ₁, 906 ₂, 906 _(N) . . . , each PFMbeing representative of a particular request type. Illustratively, anorder request PFM 906 ₁ and a punch out PFM 906 ₂ are shown. A third PFM906 _(N) indicates that any number of PFMs may be provided for. Whendeployed, the PMFs produce runtime metadata 908 configured to handlerequests received from trading entities (e.g., trading partners).

The overall operation of a B2B environment (such as the B2B environment400 shown in FIG. 4) may be described with reference to FIG. 10. FIG. 10shows a supplier system 1000 comprising a flow manager 1002, anapplication 1004 for servicing incoming requests and providing responsesand a plurality of specification artifacts 1006. The specificationartifacts 1006 comprise RMFs 1006A, PFMs 1006B and ACDs 1006C. Thesupplier system 1000 is configured to receive a request and provide anappropriate response to a requesting entity (e.g., a trading partner).

In general, steps ‘A-D’ represent development and deployment. At step‘A’ the appropriate RMF 1006A is identified according to a requestprotocol to be supported by the supplier system 1000. At step ‘B’ an ACD1006B is created to describe the interface to the application 1004. Atstep ‘C’ the PFM 1006C correlating the request protocol with theappropriate application 1004 is created. Step ‘D’ represents deploymentat which point runtime metadata is generated from the RMF, PFM and ACD.Step ‘D’ may be facilitated by a tool, such as the process deploymenttool 413A shown in FIG. 4. The supplier system 1000 is now configured toreceive requests.

Steps ‘E-G’ represent processing of a request. A request 1008 isreceived at step ‘E’ and provided to the flow manager 1002 at step ‘F’.The flow manager 1002 processes the request according to predefinedruntime metadata. The runtime metadata describes the sequence ofapplications to be invoked to handle the request, the access method usedto invoke a particular application and how to transform data providedwith the request into a format that is supported by each of theapplications invoked to handle a request. At step ‘G’ the application1004 is invoked to process the request 1008. At this point the requestis in a format understandable to the application 1004.

The operation of the flow manager after being configured with runtimemetadata may be illustrated in more detail with reference to FIG. 11which shows a flow manager method 1100. Reference is also made to FIG. 7which shows one embodiment a runtime metadata document 700. The method1100 is entered at step 1102 and proceeds to step 1104 where theback-end flow manager reads a file (e.g. runtime metadata document 700)containing the runtime metadata. At step 1106, the flow manager standsby for a request from the gateway 406. When a request is received, themethod takes steps to process the request according to the metadata 422.

At step 1108, the flow manager locates a flow to determine whatprocessing to perform for the request. In particular, the flow managersearches a selection element for a corresponding flow descriptionelement (Flow element). A flow description element specifies the set ofapplications to invoke to perform the processing of the request and thegeneration of the response. A flow description element contains asequence of step elements. Each step element represents a description ofhow to invoke the application and indicates the next step to processafter the current step is complete. The flow manager utilizes the stepelement to invoke the application and to locate the next step elementwhen the current step element is complete. Accordingly, at step 1110,the flow manager enters a loop which is repeated for each step of theselected flow description element.

At step 1111, the flow manager determines which application to invokeaccording to the selected flow. At step 1112, the appropriate accessmethod 414 for the application is called. The access method 414 isdefined by the ConnectorInterface element 720 (which also describes howto invoke the application). The ConnectorInterface element 720 containsthe name of a Java class that implements an access method 414, theproperties of the access method 414, a set of data about the inputfields of an application 412 and a set of data about the output fieldsof the application 412. The ConnectorInterface is the part of theConnector element 708 that is specific to the application being invoked.It is the Runtime Metadata form of information found in an ACD. AConnector 708 contains a reference to a ConnectorInterface 720. Inaddition to this reference, a Connector 708 contains mapping rules whichdescribe how data is mapped into and from the referencedConnectorInterface 720. This allows a given ConnectorInterface 720(which represents an ACD) to be used by a number of Connector instances,each with a different set of mapping rules targeting the sameapplication. In other words, the same ConnectorInterface 720 can be usedby one Connector 708 describing how data from cXML is mapped to theConnectorInterface 720 and a second Connector 708 describing how mXMLdata is mapped to the same ConnectorInterface 720. When processing astep element, the flow manager reads the connector element 708 andinvokes the access method (Program Call, Queue or Java) implementationthat performs the mapping of the data. The access method implementationwill use the Property elements 710 to set up the operating environmentfor the application.

At step 1114, the access method implementation gets a list of inputfield elements that describe the input parameters (or message fields)that the application requires. At step 1116, the method 1100 enters aprocess (steps 1118 and 1120) performed for each field element in thelist. At step 1118, the access method invokes a Mapin method. The Mapinmethod will take a Field element and find a corresponding Mapin element.The Mapin element will indicate where the value that this field islooking for is located at (i.e., the field in the request message). TheMapin method will retrieve that value, and perform any data typeconversion that is required. Any necessary data type conversion is knownbecause the Field element specifies what data type the application isexpecting for this parameter. The Mapin method will return the valuefrom the request message, in the proper data type, to the access method.At step 1120, the access method places the value in the appropriateplace for the application to get access to it upon invocation. Forexample, the program call access method 414B will put the value inmemory is a structure that the application will understand. When theprogram call access method invokes the application, it passes to theapplication the memory location.

The method 1100 then returns to step 1116 to begin processing the nextinput field element. In this manner, the access method 414 continuesprocessing Field elements, invoking Mapin methods to extract the values,until all the input Field elements have been processed.

At step 1122, the access method 414 invokes the application in theaccess method specific technique. For example, the program call accessmethod 414B will call the application passing in the memory location ofthe parameters, the queue access method 414C will put a message on aqueue, etc.

After the application is invoked, the access method 414 gets a list ofoutput Field elements at step 1124. The output field elements providethe location of the output values to be located by the access method. Atstep 1126, then the access method starts processing the output fieldsone at a time. At step 1128, the access method then extracts the outputvalue using the technique specific to that access method. Once the valuefor a field is extracted, the access method will invoke the Mapoutmethod at step 1130. The Mapout method is configured to locate thecorresponding Mapout element and the corresponding lnsertSpec element.The Mapout element indicates where to store the value in the responsemessage while the InsertSpec element indicates how to insert the valuein the response message. The response message has a specific order forthe fields that is specific to each B2B protocol. The InsertSpec elementcontains a specification of the field order of the response message andallows the access method to store output field values in the responsemessage without concern for the order of the fields. Accordingly, thefields can be specified in an order that is independent of the responsemessage. In this way, the Mapout method takes as input the value tostore from the access method, then using the Mapout element andInsertSpec element, the Mapout method places the value in theappropriate place in the response message. This process (i.e., steps1128 and 1130) is repeated for each output field element at which pointthe access method then returns to the flow manager and the methodreturns to step 1110.

At step 1110, the flow manager then gets the next step to process fromthe Step element. When all step elements have been processed, theresponse message is placed on queue, at step 1132, to send to thegateway 404.

A particular example of a flow manager operation is described withreference to FIG. 12. FIG. 12 shows supplier system 1200 configured toprocess a “price check” request. In general, the supplier system 1200comprises a flow manager 1202, an access method 1204 and an application1206. Illustratively, the incoming request 1208 is a “price check”formatted according to a protocol that the supplier system 1200 hasalready been configured to process. To this end, the flow manager 1202is configured with metadata 1209 used to process the request 1208.

Ilustratively, the price check request 1208 includes an item field 1210,a quantity field 1212 and a price field 1214. The application 1206 has acorresponding item field 1216, quantity field 1218 and price field 1220.Upon receiving the request 1208, the flow manager 1202 refers to themetadata 1209 to determine a type/format of the request 1208, find theappropriate fields of the request 1208 to be accessed, call theappropriate access plan 1204, and then return information to fulfill therequest 1208.

Tools

As described above, some embodiments employ tools for development anddeployment of data structures and other artifacts of a supplier system.The following provides a description of some tools that may be used toadvantage. It is understood that the tools described herein are merelyillustrative and those skilled in the art will readily identify othermethods and tools which may be used to the same end.

FIGS. 13-14 show an embodiment of GUIs for the Business Process EditorTool (BPET) 413B. In one embodiment, the BPET 413B is a Java GUI toolused to create and update information associated with access methodinstances (e.g., ACDs) and to create and update business process flowinformation (e.g., PFMs) designed to handle particular B2B requests.Illustratively, the BPET 413B may be configured to run on either aWindows NT or Windows 2000 client and can be used while connected via aTCP/IP network to the host that supports a B2B instance or in standalonemode where no connection exists to the host containing the suppliersystem runtime environment. A publish operation may be employed totransfer complete ACD or PFM definitions to a host where it can bedeployed to a B2B instance running on that host.

Illustratively, the BPET 413B is presented as a single GUI panel withseparate tabs 1302 and 1304 used to navigate from an application accessmethod edit mode to a process flow edit mode. FIG. 13 shows a BPET GUI1300 when the when an application access method tab 1302 is selected.The application access method edit tab 1302 is used to captureinformation required to define an instance of an access method 414,including the properties and input/output fields supported by the accessmethod instance. Table XIII shows information which can be specifiedusing this interface.

TABLE XIII GUI Control Name Description Access Name associated with thisaccess method instance. Names Method must be unique since they are usedto reference a given Name access method instance from a business processflow (PFM). Access Defines the type of access method for this accessMethod method instance. Specific properties and the type of input/outputmessage formats allowed for the access method instance are defined bythe access method. Selection of access method will affect theinformation presented in the Properties and Documents sections. Whenediting an existing access method instance definition, the Access Methodfield will be disabled; thereby preventing a user from changing theaccess method for an existing access method instance. PropertiesName/value pairs defining information needed by a particular accessmethod to service requests at run- time. The set of name/valueproperties is specific to each access method type. Documents Identifiesan XML document or PCML document, for example, which defines the inputand output fields supported by the individual access method instance.Input document defines the set of fields supported as input to theaccess method instance. Output document defines the set of fields thatare returned by the access method instance. When PCML is used, the samedocument will typically appear for both input and output. When documenttype is XML, the element and attribute names defined by the XML documentrepresent the candidate set of fields supported by the access methodinstance. When the document type is PCML, the data and structureelements defined by the PCML document represent the candidate field setfor the access method instance. Field ID A hierarchical view showing theset of candidate input and output fields supported by the access methodinstance as defined by the specified input and output documents,respectively. Name Used to assign a more intuitive name (e.g., an alias)to a particular field defined in either the input or output document forthis access method instance. Values specified for Name will be displayedwhen mapping B2B request fields to access method fields on the ProcessFlow tab of the Business Process Editor. Default Used to assign adefault value to a particular field. Default value is used if field isnot explicitly mapped from data contained in the incoming B2B request.Display Used to control whether a field is displayed when mapping B2Brequest data to fields associated with the access method. Deselectingdisplay will cause the field to be treated as “hidden” so that it won'tbe displayed on the Process Flow tab and cannot be the source or targetfor data mapped from the B2B request being handled by this access methodinstance.

Table XIV shows illustrative actions that are available as menu optionsfrom the BPET GUI 1300 while the application access method tab 1302 isselected and while working with access method instances.

TABLE XIV Menu Option Action File -> New Create a new access methodinstance definition. Only Name and Access Method will be shown untilAccess Method is selected. File -> Bring up browse interface to locatepre-existing Open... access method instance file for update. File ->Save Save changes made to this access method instance. File -> SaveBring up browser interface to select file name and As... location tosave this access method instance definition under. File -> Exit Exit theBusiness Process Editor. Edit->Cut Cuts the selected text to the systemclipboard. Edit->Copy Copies the selected text to the system clipboard.Edit->Paste Pastes current text from a system clipboard to the currentcursor location. Publish Select a host system and B2B instance to send acompleted PFM and access method instance definitions to. A publishoperation stores the completed PFM and access method instance definitionon a B2B server from which it can be deployed to the runtimeenvironment. Help Brings up online help for the Business Process Editor.

FIG. 14 shows the BPET GUI 1300 when the when a process flow edit tab1304 is selected. The process flow edit tab 1304 is used to describe aprocess flow model, including the type of B2B request to be serviced,the ACD to be invoked to handle the request and information describinghow data provided with the B2B request is mapped to input fieldssupported by the ACD and how data returned by the access method instanceis mapped to the response data format supported by the particular B2Brequest. Illustrative information that can be specified using thisinterface is shown in Table XV. The menu options for the process flowsection of the BPET GUI 1300 are the same as those provided when theapplication access method tab 1302 is active. (See Table XIV).

TABLE XV GUI Control Name Description Protocol Allows a user to choosethe protocol to be serviced by this process flow definition. Action TheAction dropdown is based on the selected protocol. Allows a user tochoose the action to be serviced by this process flow definition. AccessThis dropdown displays the list of available access method Methodinstances. Access method instances are defined using the NameApplication Access method tab. Allows a user to choose the access methodinstance that will be used to handle B2B requests of the specifiedprotocol and action. Once an action and an access method are selected,the Load button is enabled. When the Load button is clicked: I. TheRequest Fields and Response Fields in the Input Mappings and OutputMappings sections are filled with the fields associated with the chosenprotocol/action. II. The Access Method Fields in the Input Mappings andOutput Mappings sections are filled with the fields associated with thechosen access method instance. Input Shows the set of fields providedwith this type of B2B Mappings request and the input fields supported bythe specified access method instance. User may select a Request Fieldand an Access Method Field and click Add Mapping to indicate that theRequest Field is to be mapped to the selected Access Method Field atruntime. This data mapping associa- tion is displayed in the MappingTable at the bottom of the Business Process Editor screen. Output Showsthe set of fields returned by the specified access Mappings method andthe set of fields that make up the response message for this type of B2Brequest. User may select a Response Field and an Access Method Field andclick Add Mapping to indicate that the Access Method Field is to bemapped to the selected Response Field at runtime. This data mappingassociation is displayed in the Mapping Table at the bottom of theBusiness Process Editor screen. Mapping This table lists all of the datamappings that have been Table defined between Request/Response datafields associated with this type of B2B request and the input and outputfields associated with the specified access method instance. To remove amapping from the table, select the row containing the mapping and clickRemove. To remove all mappings from the table, click Remove All. Awarning message appears to confirm this operation.

FIGS. 15-17 show embodiments of GUIs for the Process Deployment Tool(PDT) 413A. Illustratively, the PDT GUIs are a web-based interfaces usedto deploy a complete business process flow (PFM) and associated accessmethod instance definition (ACD) into the runtime environment supportinga particular instance of a B2B server configured to process B2Brequests. The PDT 413A runs within the context of a given B2B serverinstance, allowing the business process flows defined for that instanceto be updated or extended. In essence, the PDT 413A will convert one ormore PFM/ACD pairs into the runtime metadata format required by the FlowManager responsible for handling incoming B2B requests within a givenB2B server instance.

A primary task in the deployment process is the association of aparticular PFM with the B2B request the flow is designed to service. Inone embodiment, requests can be qualified by B2B marketplace, B2Bprotocol, transaction type and subtype, buying organization andsupplier. Thus, the act of deployment involves (1) user selection ofvalues for all of the B2B request qualifiers (e.g., protocol, protocolversion, marketplace, request type, buyer and supplier), (2) useridentification of the business process flow (PFM) that will handle theserequests, (3) generation of runtime metadata representing theseselections and (4) storage of this information in the runtimeenvironment associated with the B2B instance. These four (4) steps aresupported by one embodiment of the PDT 413A.

In one embodiment, a wizard-like interface is provided to walk a userthrough the set of selections required to deploy a new PFM or to viewthe set of current PFM that are currently defined to a B2B instance. Anembodiment of the “wizard-like interface” is illustrated with respect toFIGS. 15-17. A protocol selection screen 1500 of the wizard for the PDT413A, shown in FIG. 15, allows a particular B2B protocol to be selected.Only those protocols supported by a B2B instance will be shown to theuser. Illustratively, a protocol selection window 1502 shows Ariba andMetiom as available protocols.

Clicking on the “Next” button on the protocol selection screen 1500 willbring up a marketplace selection screen where a particular marketplacesupporting the chosen protocol can be selected. An illustrativemarketplace selection screen 1600 is shown in FIG. 16. Only thosemarketplaces for the selected protocol will be shown in the marketplacelist on this screen. The available marketplaces may be shown by clickingon a dropdown button 1604 of a marketplace selection window 1602.

Once marketplace is chosen, clicking on the “Next” button on themarketplace selection screen 1600 will bring up a market configurationscreen. An illustrative market configuration screen 1700 is shown inFIG. 17. The market configuration screen 1700 provides a configurationwindow 1701 which includes a request list 1702 of B2B requests that arecurrently supported for the selected marketplace and a PFM column 1704(titled “Operation (Flow)”) identifying the PFM specified to handle eachrequest. For a newly defined marketplace, the request list 1702initially contains a transaction column 1706 and a subtype column 1708for the set of B2B transaction types/subtypes defined by the B2Bprotocol associated with marketplace. Only those transactiontypes/subtypes enabled for the current B2B instance are shown.

Clicking an “Advanced” button displays a buyer column 1712 and a sellercolumn 1714. The columns 1712 and 1714 provide a list of buyingorganizations and supplier organizations, respectively, that areauthorized to conduct commerce within a given marketplace. Accordingly,association of PFMs specific to a given buyer/supplier relationship isprovided, thereby allowing definition of one PFM for one buyer/supplierpair and another PFM for another buyer/supplier pair. For example, onePFM may be defined for a large corporate buyer and another PFM may bedefined for a sole proprietor.

In one embodiment, the buyer and supplier settings will be defaulted to*ALL, and the corresponding PFM entry in the PFM column 1704 will beempty since no business process flows have yet been identified to handleB2B requests from this marketplace. Defaulting to *ALL means thespecified PFM will apply to request associated with all buyers and allsuppliers.

From this initial screen, the user may select a PFM from the PFM column1704 to handle a given request type. Only those PFMs that have beenpublished to the B2B instance server and which support the selected B2Brequest type will be shown to the user for selection. Once a PFM hasbeen selected, the user may enable or disable handling of the B2Brequest by using the checkbox provided in a checkbox column 1710.

The Advanced button can be used if the user wishes to qualify theselected PFM based on the buyer organization and/or supplier associatedwith the B2B request. In one embodiment, only associations between buyerorganization and supplier that have been previously specified will beallowed. Specification of specific buyer organization or supplier toqualify a B2B request will result in a new row in the configurationwindow 1701, allowing a different PFM to be defined for a given buyerorganization/supplier pair than that used for similar requests betweenother buyers and suppliers.

Once all changes have been made on this screen, a “Deploy” button isused to deploy these B2B request-to-PFM selections to the runtimeenvironment for the current B2B instance.

While the foregoing is directed to the preferred embodiment of thepresent invention, other and further embodiments of the invention may bedevised without departing from the basic scope thereof, and the scopethereof is determined by the claims that follow.

1. A method of processing eCommerce requests, comprising: receiving arequest of a first request type, wherein requests of the first requesttype includes a first plurality of input fields; in response toreceiving the request of the first request type, determining anapplication to invoke, wherein the application is configured to processa request of a second request type, wherein requests of the secondrequest type includes a second plurality of input fields; invoking aninstance of an access method, wherein the access method defines aninterface of the application for the second request type; mapping one ormore of the first plurality of input fields to the second plurality ofinput fields, wherein the mapping comprises, for each field of thesecond plurality of input fields: extracting a value from at least oneof the first plurality of input fields, and arranging the valueaccording to a definition specified by the access method; invoking theapplication by passing the second plurality of input fields to theinterface of the application for the second request type; receiving, inresponse to invoking the application, a response that includes one ormore output fields; and generating a response of a first response typeby mapping the received one or more output fields to a mapped pluralityof output fields, wherein the mapped plurality of output fieldscorresponds to a plurality of output fields of the first response type.2. The method of claim 1, wherein determining the application to invokecomprises selecting a sequence of applications to invoke and whereininvoking the application comprises invoking a plurality of applicationaccording to the sequence.
 3. The method of claim 1, wherein invokingthe instance of the access method further comprises selecting the accessmethod from one of a plurality of access methods, each of the pluralityof access methods configured to define a particular interface for aparticular type of application.
 4. A method for deploying computerinfrastructure, comprising intergrating computer readable into acomputer system, wherein the code in combination with the computersystem is capable of performing a method of processing eCommercerequests comprising: receiving a request of a first request type,wherein the first request includes a first plurality of input fields; inresponse to receiving the request, determining an application to invoke,wherein the application is configured to process a request of a secondrequest type, wherein the second request includes a second plurality ofinput fields; invoking an instance of an access method, wherein theaccess method defines an interface of the application for the secondrequest type; mapping one or more of the first plurality of input fieldsto the second plurality of input fields, wherein the mapping comprises,for each field of the second plurality of input fields: extracting avalue from at least one of the first plurality of input fields of therequest of the first request type, and arranging the value according toa definition specified by the access method; invoking the application bypassing the second plurality of input fields to the interface of theapplication for the second request type; receiving, in response toinvoking the application, a response that includes one or more outputfields; and generating a response of a first response type by mappingthe received one or more output fields to a mapped plurality of outputfields, wherein the mapped plurality of output fields corresponds to aplurality of output fields of the first response type.